Page({
  data: {
    userInfo: {},
    showFrameSelection: false,
    availableFrames: [
      {
        id: 'frame1',
        name: '蓝色边框',
        url: '/images/frames/blue-frame.png'
      },
      {
        id: 'frame2',
        name: '金色边框',
        url: '/images/frames/gold-frame.png'
      },
      {
        id: 'frame3',
        name: '银色边框',
        url: '/images/frames/silver-frame.png'
      },
      {
        id: 'frame4',
        name: '闪光边框',
        url: '/images/frames/flash-frame.png'
      },
      {
        id: 'frame5',
        name: '星星边框',
        url: '/images/frames/star-frame.png'
      },
      {
        id: 'frame6',
        name: '学霸边框',
        url: '/images/frames/student-frame.png'
      }
    ],
    selectedFrameIndex: -1,
    tempSelectedFrame: null,
    showAvatarButton: false
  },
  
  onLoad: function(options) {
    wx.setNavigationBarTitle({
      title: '头像编辑'
    });
    
    // 获取用户信息
    this.getUserInfo();
    
    // 注册页面实例
    const app = getApp();
    const pages = getCurrentPages();
    const currentPage = pages[pages.length - 1];
    const pageName = currentPage.route;
    app.registerPage(pageName, this);
  },
  
  onUnload: function() {
    // 注销页面实例
    const app = getApp();
    const pages = getCurrentPages();
    const currentPage = pages[pages.length - 1];
    const pageName = currentPage.route;
    app.unregisterPage(pageName);
  },
  
  getUserInfo: function() {
    try {
      const userInfo = wx.getStorageSync('userInfo') || {
        avatarUrl: 'https://objectstorageapi.bja.sealos.run/a0qepsyj-001/text/profile/default-avatar.jpg',
        avatarFrame: null
      };
      
      this.setData({ userInfo });
      
      // 如果用户有头像框，找到对应索引
      if (userInfo.avatarFrame) {
        const frameIndex = this.data.availableFrames.findIndex(frame => frame.url === userInfo.avatarFrame);
        this.setData({ selectedFrameIndex: frameIndex >= 0 ? frameIndex : -1 });
      }
    } catch (e) {
      console.error('获取用户信息失败', e);
    }
  },
  
  // 选择新头像
  chooseAvatar: function() {
    const app = getApp();
    const tokenManager = require('../../utils/tokenManager');
    const storage = require('../../utils/storage.js');
    
    // 检查登录状态
    if (!tokenManager.isLoggedIn()) {
      wx.showToast({
        title: '请先登录',
        icon: 'none',
        duration: 2000
      });
      return;
    }
    
    wx.chooseImage({
      count: 1,
      sizeType: ['compressed'],
      sourceType: ['album', 'camera'],
      success: (res) => {
        // 获取选择的图片临时路径
        const tempFilePath = res.tempFilePaths[0];
        
        // 显示上传中状态
        wx.showLoading({
          title: '更新中...',
          mask: true
        });
        
        // 更新本地状态
        this.setData({
          'userInfo.avatarUrl': tempFilePath
        });
        
        // 尝试使用API上传头像
        const token = tokenManager.getAccessToken();
        console.log('开始调用API上传头像');
        
        try {
          app.api.user.updateAvatar(token, tempFilePath)
            .then(result => {
              console.log('头像上传成功:', result);
              
              // 隐藏加载状态
              wx.hideLoading();
              
              // 更新本地用户头像URL（添加时间戳防止缓存）
              const timestamp = Date.now();
              let avatarUrl = result.avatar || this.data.userInfo.avatarUrl;
              avatarUrl = avatarUrl.includes('?') 
                ? `${avatarUrl}&t=${timestamp}` 
                : `${avatarUrl}?t=${timestamp}`;
              
              // 更新本地状态
              this.setData({
                'userInfo.avatarUrl': avatarUrl
              });
              
              // 保存更改到本地存储
              this.saveUserInfo();
              
              // 清除旧头像的缓存
              storage.clearWxImageCache(avatarUrl);
              
              // 显示成功提示，并在提示消失后返回上一页
              wx.showToast({
                title: '头像已更新',
                icon: 'success',
                duration: 1500,
                success: () => {
                  // 设置标记，表示需要刷新用户信息
                  app.globalData.needRefreshUserInfo = true;
                  
                  // 使用app全局方法更新头像(会同时清除缓存)
                  app.updateUserAvatar(avatarUrl);
                  
                  // 延迟返回上一页，确保刷新
                  setTimeout(() => {
                    wx.navigateBack({
                      delta: 1
                    });
                  }, 1500);
                }
              });
            })
            .catch(error => {
              console.error('API头像上传失败:', error);
              
              // API上传失败，使用本地保存
              wx.hideLoading();
              
              // 保存更改到本地存储
              this.saveUserInfo();
              
              // 设置标记，表示需要刷新用户信息
              app.globalData.needRefreshUserInfo = true;
              
              // 使用app全局方法更新头像(会同时清除缓存)
              app.updateUserAvatar(tempFilePath);
              
              // 显示成功提示，并在提示消失后返回上一页
              wx.showToast({
                title: '头像已保存(本地)',
                icon: 'success',
                duration: 1500,
                success: () => {
                  // 延迟返回上一页，确保刷新
                  setTimeout(() => {
                    wx.navigateBack({
                      delta: 1
                    });
                  }, 1500);
                }
              });
            });
        } catch (e) {
          console.error('头像上传异常:', e);
          
          // 异常情况下，使用本地保存
          wx.hideLoading();
          
          // 保存更改到本地存储
          this.saveUserInfo();
          
          // 设置标记，表示需要刷新用户信息
          app.globalData.needRefreshUserInfo = true;
          
          // 使用app全局方法更新头像(会同时清除缓存)
          app.updateUserAvatar(tempFilePath);
          
          // 显示成功提示，并在提示消失后返回上一页
          wx.showToast({
            title: '头像已保存(本地)',
            icon: 'success',
            duration: 1500,
            success: () => {
              // 延迟返回上一页，确保刷新
              setTimeout(() => {
                wx.navigateBack({
                  delta: 1
                });
              }, 1500);
            }
          });
        }
      }
    });
  },
  
  // 获取头像框
  getAvatarFrames: function() {
    wx.showModal({
      title: '获取头像框',
      content: '可以通过参加活动、完成任务等方式获取更多头像框。\n\n目前您可以使用系统提供的默认头像框。',
      showCancel: false,
      confirmText: '我知道了'
    });
  },
  
  // 使用已有头像框
  useAvatarFrame: function() {
    this.setData({
      showFrameSelection: true,
      tempSelectedFrame: this.data.selectedFrameIndex
    });
  },
  
  // 选择头像框
  selectFrame: function(e) {
    const index = e.currentTarget.dataset.index;
    this.setData({
      tempSelectedFrame: index
    });
  },
  
  // 取消选择头像框
  cancelFrameSelection: function() {
    this.setData({
      showFrameSelection: false,
      tempSelectedFrame: null
    });
  },
  
  // 确认选择头像框
  confirmFrameSelection: function() {
    const index = this.data.tempSelectedFrame;
    
    this.setData({
      selectedFrameIndex: index,
      showFrameSelection: false
    });
    
    // 设置头像框
    if (index === -1) {
      // 不使用头像框
      this.setData({
        'userInfo.avatarFrame': null
      });
    } else {
      // 使用选中的头像框
      this.setData({
        'userInfo.avatarFrame': this.data.availableFrames[index].url
      });
    }
    
    // 保存更改
    this.saveUserInfo();
    
    wx.showToast({
      title: index === -1 ? '已移除头像框' : '头像框已应用',
      icon: 'success'
    });
  },
  
  // 保存用户信息到本地存储
  saveUserInfo: function() {
    try {
      const app = getApp();
      
      // 使用全局更新方法
      const success = app.updateUserAvatar(this.data.userInfo.avatarUrl);
      
      if (success) {
        console.log('头像更新成功，所有页面将自动刷新');
      } else {
        console.error('头像更新失败');
      }
      
      // 头像框需要单独处理（如果需要）
      if (this.data.userInfo.avatarFrame !== undefined) {
        const userInfo = wx.getStorageSync('userInfo') || {};
        userInfo.avatarFrame = this.data.userInfo.avatarFrame;
        wx.setStorageSync('userInfo', userInfo);
      }
      
      // 设置全局标记，表示需要刷新用户信息
      app.globalData.needRefreshUserInfo = true;
    } catch (e) {
      console.error('保存用户信息失败', e);
    }
  },
  
  // 从微信获取头像
  getWechatAvatar: function() {
    const app = getApp();
    const tokenManager = require('../../utils/tokenManager');
    
    // 检查登录状态
    if (!tokenManager.isLoggedIn()) {
      wx.showToast({
        title: '请先登录',
        icon: 'none',
        duration: 2000
      });
      return;
    }
    
    // 显示提示
    wx.showToast({
      title: '请点击下方按钮选择头像',
      icon: 'none',
      duration: 2000
    });
    
    // 注意：在微信小程序新版API中，获取头像需要在wxml中使用特定的button组件
    // <button open-type="chooseAvatar" bindchooseavatar="onChooseAvatar">获取头像</button>
    // 该按钮会触发onChooseAvatar方法，我们在onLoad中注册一个标记，指示当前是通过getWechatAvatar调用的
    this.setData({
      showAvatarButton: true
    });
  },
  
  // 处理用户选择头像事件
  onChooseAvatar: function(e) {
    console.log('用户选择了头像', e);
    
    const app = getApp();
    const tokenManager = require('../../utils/tokenManager');
    const storage = require('../../utils/storage.js');
    
    if (e.detail && e.detail.avatarUrl) {
      // 显示加载中
      wx.showLoading({
        title: '更新中...',
        mask: true
      });
      
      // 获取临时头像文件
      const tempFilePath = e.detail.avatarUrl;
      
      // 更新本地状态
      this.setData({
        'userInfo.avatarUrl': tempFilePath,
        showAvatarButton: false // 隐藏按钮
      });
      
      // 尝试使用API上传头像
      const token = tokenManager.getAccessToken();
      console.log('开始调用API上传微信头像');
      
      try {
        app.api.user.updateAvatar(token, tempFilePath)
          .then(result => {
            console.log('微信头像上传成功:', result);
            
            // 隐藏加载状态
            wx.hideLoading();
            
            // 更新本地用户头像URL（添加时间戳防止缓存）
            const timestamp = Date.now();
            let avatarUrl = result.avatar || this.data.userInfo.avatarUrl;
            avatarUrl = avatarUrl.includes('?') 
              ? `${avatarUrl}&t=${timestamp}` 
              : `${avatarUrl}?t=${timestamp}`;
            
            // 更新本地状态
            this.setData({
              'userInfo.avatarUrl': avatarUrl
            });
            
            // 清除旧头像的缓存
            storage.clearWxImageCache(avatarUrl);
            
            // 使用app全局方法更新头像(会同时清除缓存)
            app.updateUserAvatar(avatarUrl);
            
            // 显示成功提示，并在提示消失后返回上一页
            wx.showToast({
              title: '头像已更新',
              icon: 'success',
              duration: 1500,
              success: () => {
                // 设置全局标记，表示需要刷新用户信息
                app.globalData.needRefreshUserInfo = true;
                
                // 延迟返回上一页，确保刷新
                setTimeout(() => {
                  wx.navigateBack({
                    delta: 1
                  });
                }, 1500);
              }
            });
          })
          .catch(error => {
            console.error('API微信头像上传失败:', error);
            
            // API上传失败，使用本地保存
            wx.hideLoading();
            
            // 保存更改到本地存储
            this.saveUserInfo();
            
            // 显示成功提示，并在提示消失后返回上一页
            wx.showToast({
              title: '头像已保存(本地)',
              icon: 'success',
              duration: 1500,
              success: () => {
                // 设置全局标记，表示需要刷新用户信息
                app.globalData.needRefreshUserInfo = true;
                
                // 延迟返回上一页，确保刷新
                setTimeout(() => {
                  wx.navigateBack({
                    delta: 1
                  });
                }, 1500);
              }
            });
          });
      } catch (e) {
        console.error('微信头像上传异常:', e);
        
        // 异常情况下，使用本地保存
        wx.hideLoading();
        
        // 保存更改到本地存储
        this.saveUserInfo();
        
        // 显示成功提示，并在提示消失后返回上一页
        wx.showToast({
          title: '头像已保存(本地)',
          icon: 'success',
          duration: 1500,
          success: () => {
            // 设置全局标记，表示需要刷新用户信息
            app.globalData.needRefreshUserInfo = true;
            
            // 延迟返回上一页，确保刷新
            setTimeout(() => {
              wx.navigateBack({
                delta: 1
              });
            }, 1500);
          }
        });
      }
    }
  },
  
  // 选择系统头像
  onChooseAvatar(e) {
    console.log('选择系统头像', e);
    const { avatarUrl } = e.detail;
    
    if (!avatarUrl) {
      return wx.showToast({
        title: '获取头像失败',
        icon: 'none'
      });
    }
    
    // 显示加载中
    wx.showLoading({
      title: '保存中...',
      mask: true
    });
    
    // 更新本地头像显示
    this.setData({
      avatarUrl: avatarUrl
    });
    
    // 由于后端接口不可用，我们在这里模拟保存成功
    // 注释掉原API调用部分
    /*
    app.request({
      url: '/api/user/update-avatar',
      method: 'POST',
      data: {
        avatarUrl: avatarUrl
      },
      success: (res) => {
        // 处理接口响应
      },
      fail: (err) => {
        // 处理错误
      },
      complete: () => {
        wx.hideLoading();
      }
    });
    */
    
    // 直接使用全局头像更新方法
    setTimeout(() => {
      wx.hideLoading();
      
      // 使用app全局方法更新头像(会同时清除缓存)
      const success = app.updateUserAvatar(avatarUrl);
      
      if (success) {
        wx.showToast({
          title: '保存成功',
          icon: 'success',
          duration: 1500
        });
        
        // 设置全局标记，表示需要刷新用户信息
        app.globalData.needRefreshUserInfo = true;
        
        // 延迟返回，确保Toast能够显示
        setTimeout(() => {
          wx.navigateBack();
        }, 1500);
      } else {
        wx.showToast({
          title: '保存失败',
          icon: 'none'
        });
      }
    }, 1000);
  },
  
  // 选择本地图片作为头像
  chooseAvatar() {
    // 检查登录状态
    if (!app.tokenManager.isLoggedIn()) {
      return wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
    }
    
    wx.chooseImage({
      count: 1,
      sizeType: ['compressed'],
      sourceType: ['album', 'camera'],
      success: (res) => {
        const tempFilePath = res.tempFilePaths[0];
        
        // 显示加载中
        wx.showLoading({
          title: '保存中...',
          mask: true
        });
        
        // 更新本地头像显示
        this.setData({
          avatarUrl: tempFilePath
        });
        
        // 由于后端接口不可用，我们在这里模拟上传成功
        // 注释掉原API调用部分
        /*
        wx.uploadFile({
          url: app.globalData.apiBaseUrl + '/api/user/upload-avatar',
          filePath: tempFilePath,
          name: 'avatar',
          header: {
            'Authorization': 'Bearer ' + app.tokenManager.getToken()
          },
          success: (uploadRes) => {
            // 处理上传响应
          },
          fail: (err) => {
            // 处理错误
          },
          complete: () => {
            wx.hideLoading();
          }
        });
        */
        
        // 直接使用全局头像更新方法
        setTimeout(() => {
          wx.hideLoading();
          
          // 使用app全局方法更新头像(会同时清除缓存)
          const success = app.updateUserAvatar(tempFilePath);
          
          if (success) {
            // 强制清除旧头像缓存
            storage.clearAllWxImageCache();
            
            wx.showToast({
              title: '保存成功',
              icon: 'success',
              duration: 1500
            });
            
            // 设置全局标记，表示需要刷新用户信息
            app.globalData.needRefreshUserInfo = true;
            
            // 延迟返回，确保Toast能够显示
            setTimeout(() => {
              wx.navigateBack();
            }, 1500);
          } else {
            wx.showToast({
              title: '保存失败',
              icon: 'none'
            });
          }
        }, 1000);
      }
    });
  }
}); 